// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.nav.order.rule;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.NavOrderRule;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(NavOrderRule.class)
@Setter
@Getter
public class NavOrderRuleSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "NavOrderRule".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("baseOrderSite", "sr");
    map.put("baseOrderShopInfo", "si");
    map.put("deliveryWarehouse", "w");
    map.put("logisticsProvider", "nlp");
    map.put("logisticsChannel", "nlcv");
    map.put("warehouseActDeliveryWarehouse", "w2");
    map.put("warehouseActOptionWarehouse", "w3");
    map.put("logisticsActChannel", "nlcv2");
    map.put("createUser", "su");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：NavOrderRule/Split, NavOrderRule/Join, NavOrderRule/Warehouse, NavOrderRule/Logistics, NavOrderRule/Address, NavOrderRule/Process, NavOrderRule/Issu
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 规则名称(模糊搜索)
   */
  private String name;

  /**
   * 规则名称 比较(eq)
   */
  private String nameEq;
  /**
   * 规则名称 比较(neq)
   */
  private String nameNeq;
  /**
   * 规则名称 比较(gt)
   */
  private String nameGt;
  /**
   * 规则名称 比较(gte)
   */
  private String nameGte;
  /**
   * 规则名称 比较(lt)
   */
  private String nameLt;
  /**
   * 规则名称 比较(lte)
   */
  private String nameLte;
  /**
   * 规则名称 比较(contains)
   */
  private String nameContains;
  /**
   * 规则名称 比较(notcontains)
   */
  private String nameNotcontains;
  /**
   * 规则名称 比较(startswith)
   */
  private String nameStartswith;
  /**
   * 规则名称 比较(endswith)
   */
  private String nameEndswith;
  /**
   * 规则名称 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 规则名称 比较(isnotnull)
   */
  private Boolean nameIsnotnull;

  /**
   * 规则名称(精确搜索)
   */
  private List<String> nameInList;

  /**
   * 规则类型
   */
  private String type;

  /**
   * 规则类型 比较(eq)
   */
  private String typeEq;
  /**
   * 规则类型 比较(neq)
   */
  private String typeNeq;
  /**
   * 规则类型 比较(gt)
   */
  private String typeGt;
  /**
   * 规则类型 比较(gte)
   */
  private String typeGte;
  /**
   * 规则类型 比较(lt)
   */
  private String typeLt;
  /**
   * 规则类型 比较(lte)
   */
  private String typeLte;
  /**
   * 规则类型 比较(contains)
   */
  private String typeContains;
  /**
   * 规则类型 比较(notcontains)
   */
  private String typeNotcontains;
  /**
   * 规则类型 比较(startswith)
   */
  private String typeStartswith;
  /**
   * 规则类型 比较(endswith)
   */
  private String typeEndswith;
  /**
   * 规则类型 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 规则类型 比较(isnotnull)
   */
  private Boolean typeIsnotnull;

  /**
   * 规则类型(精确搜索)
   */
  private List<String> typeInList;

  /**
   * 规则状态
   */
  private String status;

  /**
   * 规则状态 比较(eq)
   */
  private String statusEq;
  /**
   * 规则状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 规则状态 比较(gt)
   */
  private String statusGt;
  /**
   * 规则状态 比较(gte)
   */
  private String statusGte;
  /**
   * 规则状态 比较(lt)
   */
  private String statusLt;
  /**
   * 规则状态 比较(lte)
   */
  private String statusLte;
  /**
   * 规则状态 比较(contains)
   */
  private String statusContains;
  /**
   * 规则状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 规则状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 规则状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 规则状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 规则状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 规则状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 订单平台
   */
  private String baseOrderPlatform;

  /**
   * 订单平台 比较(eq)
   */
  private String baseOrderPlatformEq;
  /**
   * 订单平台 比较(neq)
   */
  private String baseOrderPlatformNeq;
  /**
   * 订单平台 比较(gt)
   */
  private String baseOrderPlatformGt;
  /**
   * 订单平台 比较(gte)
   */
  private String baseOrderPlatformGte;
  /**
   * 订单平台 比较(lt)
   */
  private String baseOrderPlatformLt;
  /**
   * 订单平台 比较(lte)
   */
  private String baseOrderPlatformLte;
  /**
   * 订单平台 比较(contains)
   */
  private String baseOrderPlatformContains;
  /**
   * 订单平台 比较(notcontains)
   */
  private String baseOrderPlatformNotcontains;
  /**
   * 订单平台 比较(startswith)
   */
  private String baseOrderPlatformStartswith;
  /**
   * 订单平台 比较(endswith)
   */
  private String baseOrderPlatformEndswith;
  /**
   * 订单平台 比较(isnull)
   */
  private Boolean baseOrderPlatformIsnull;
  /**
   * 订单平台 比较(isnotnull)
   */
  private Boolean baseOrderPlatformIsnotnull;

  /**
   * 订单平台(精确搜索)
   */
  private List<String> baseOrderPlatformInList;

  /**
   * 订单站点
   */
  private Long baseOrderSite;

  /**
   * 订单站点 比较(eq)
   */
  private Long baseOrderSiteEq;
  /**
   * 订单站点 比较(neq)
   */
  private Long baseOrderSiteNeq;
  /**
   * 订单站点 比较(gt)
   */
  private Long baseOrderSiteGt;
  /**
   * 订单站点 比较(gte)
   */
  private Long baseOrderSiteGte;
  /**
   * 订单站点 比较(lt)
   */
  private Long baseOrderSiteLt;
  /**
   * 订单站点 比较(lte)
   */
  private Long baseOrderSiteLte;
  /**
   * 订单站点 比较(contains)
   */
  private Long baseOrderSiteContains;
  /**
   * 订单站点 比较(notcontains)
   */
  private Long baseOrderSiteNotcontains;
  /**
   * 订单站点 比较(startswith)
   */
  private Long baseOrderSiteStartswith;
  /**
   * 订单站点 比较(endswith)
   */
  private Long baseOrderSiteEndswith;
  /**
   * 订单站点 比较(isnull)
   */
  private Boolean baseOrderSiteIsnull;
  /**
   * 订单站点 比较(isnotnull)
   */
  private Boolean baseOrderSiteIsnotnull;
  /**
   * 订单站点的名称 比较(eq)
   */
  private String baseOrderSiteNameEq;
  /**
   * 订单站点的名称 比较(neq)
   */
  private String baseOrderSiteNameNeq;
  /**
   * 订单站点的名称 比较(gt)
   */
  private String baseOrderSiteNameGt;
  /**
   * 订单站点的名称 比较(gte)
   */
  private String baseOrderSiteNameGte;
  /**
   * 订单站点的名称 比较(lt)
   */
  private String baseOrderSiteNameLt;
  /**
   * 订单站点的名称 比较(lte)
   */
  private String baseOrderSiteNameLte;
  /**
   * 订单站点的名称 比较(contains)
   */
  private String baseOrderSiteNameContains;
  /**
   * 订单站点的名称 比较(notcontains)
   */
  private String baseOrderSiteNameNotcontains;
  /**
   * 订单站点的名称 比较(startswith)
   */
  private String baseOrderSiteNameStartswith;
  /**
   * 订单站点的名称 比较(endswith)
   */
  private String baseOrderSiteNameEndswith;
  /**
   * 订单站点的名称 比较(isnull)
   */
  private Boolean baseOrderSiteNameIsnull;
  /**
   * 订单站点的名称 比较(isnotnull)
   */
  private Boolean baseOrderSiteNameIsnotnull;

  /**
   * 订单站点(范围搜索)
   */
  private List<Long> baseOrderSiteInList;

  /**
   * 订单店铺
   */
  private Long baseOrderShopInfo;

  /**
   * 订单店铺 比较(eq)
   */
  private Long baseOrderShopInfoEq;
  /**
   * 订单店铺 比较(neq)
   */
  private Long baseOrderShopInfoNeq;
  /**
   * 订单店铺 比较(gt)
   */
  private Long baseOrderShopInfoGt;
  /**
   * 订单店铺 比较(gte)
   */
  private Long baseOrderShopInfoGte;
  /**
   * 订单店铺 比较(lt)
   */
  private Long baseOrderShopInfoLt;
  /**
   * 订单店铺 比较(lte)
   */
  private Long baseOrderShopInfoLte;
  /**
   * 订单店铺 比较(contains)
   */
  private Long baseOrderShopInfoContains;
  /**
   * 订单店铺 比较(notcontains)
   */
  private Long baseOrderShopInfoNotcontains;
  /**
   * 订单店铺 比较(startswith)
   */
  private Long baseOrderShopInfoStartswith;
  /**
   * 订单店铺 比较(endswith)
   */
  private Long baseOrderShopInfoEndswith;
  /**
   * 订单店铺 比较(isnull)
   */
  private Boolean baseOrderShopInfoIsnull;
  /**
   * 订单店铺 比较(isnotnull)
   */
  private Boolean baseOrderShopInfoIsnotnull;
  /**
   * 订单店铺的名称 比较(eq)
   */
  private String baseOrderShopInfoShopNameEq;
  /**
   * 订单店铺的名称 比较(neq)
   */
  private String baseOrderShopInfoShopNameNeq;
  /**
   * 订单店铺的名称 比较(gt)
   */
  private String baseOrderShopInfoShopNameGt;
  /**
   * 订单店铺的名称 比较(gte)
   */
  private String baseOrderShopInfoShopNameGte;
  /**
   * 订单店铺的名称 比较(lt)
   */
  private String baseOrderShopInfoShopNameLt;
  /**
   * 订单店铺的名称 比较(lte)
   */
  private String baseOrderShopInfoShopNameLte;
  /**
   * 订单店铺的名称 比较(contains)
   */
  private String baseOrderShopInfoShopNameContains;
  /**
   * 订单店铺的名称 比较(notcontains)
   */
  private String baseOrderShopInfoShopNameNotcontains;
  /**
   * 订单店铺的名称 比较(startswith)
   */
  private String baseOrderShopInfoShopNameStartswith;
  /**
   * 订单店铺的名称 比较(endswith)
   */
  private String baseOrderShopInfoShopNameEndswith;
  /**
   * 订单店铺的名称 比较(isnull)
   */
  private Boolean baseOrderShopInfoShopNameIsnull;
  /**
   * 订单店铺的名称 比较(isnotnull)
   */
  private Boolean baseOrderShopInfoShopNameIsnotnull;

  /**
   * 订单店铺(范围搜索)
   */
  private List<Long> baseOrderShopInfoInList;

  /**
   * 发货仓库
   */
  private Long deliveryWarehouse;

  /**
   * 发货仓库 比较(eq)
   */
  private Long deliveryWarehouseEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long deliveryWarehouseNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long deliveryWarehouseGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long deliveryWarehouseGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long deliveryWarehouseLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long deliveryWarehouseLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long deliveryWarehouseContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long deliveryWarehouseNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long deliveryWarehouseStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long deliveryWarehouseEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean deliveryWarehouseIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean deliveryWarehouseIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String deliveryWarehouseNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String deliveryWarehouseNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String deliveryWarehouseNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String deliveryWarehouseNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String deliveryWarehouseNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String deliveryWarehouseNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String deliveryWarehouseNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String deliveryWarehouseNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String deliveryWarehouseNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String deliveryWarehouseNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean deliveryWarehouseNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean deliveryWarehouseNameIsnotnull;

  /**
   * 发货仓库(范围搜索)
   */
  private List<Long> deliveryWarehouseInList;

  /**
   * 物流商
   */
  private Long logisticsProvider;

  /**
   * 物流商 比较(eq)
   */
  private Long logisticsProviderEq;
  /**
   * 物流商 比较(neq)
   */
  private Long logisticsProviderNeq;
  /**
   * 物流商 比较(gt)
   */
  private Long logisticsProviderGt;
  /**
   * 物流商 比较(gte)
   */
  private Long logisticsProviderGte;
  /**
   * 物流商 比较(lt)
   */
  private Long logisticsProviderLt;
  /**
   * 物流商 比较(lte)
   */
  private Long logisticsProviderLte;
  /**
   * 物流商 比较(contains)
   */
  private Long logisticsProviderContains;
  /**
   * 物流商 比较(notcontains)
   */
  private Long logisticsProviderNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private Long logisticsProviderStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private Long logisticsProviderEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean logisticsProviderIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean logisticsProviderIsnotnull;
  /**
   * 物流商的名称 比较(eq)
   */
  private String logisticsProviderNameEq;
  /**
   * 物流商的名称 比较(neq)
   */
  private String logisticsProviderNameNeq;
  /**
   * 物流商的名称 比较(gt)
   */
  private String logisticsProviderNameGt;
  /**
   * 物流商的名称 比较(gte)
   */
  private String logisticsProviderNameGte;
  /**
   * 物流商的名称 比较(lt)
   */
  private String logisticsProviderNameLt;
  /**
   * 物流商的名称 比较(lte)
   */
  private String logisticsProviderNameLte;
  /**
   * 物流商的名称 比较(contains)
   */
  private String logisticsProviderNameContains;
  /**
   * 物流商的名称 比较(notcontains)
   */
  private String logisticsProviderNameNotcontains;
  /**
   * 物流商的名称 比较(startswith)
   */
  private String logisticsProviderNameStartswith;
  /**
   * 物流商的名称 比较(endswith)
   */
  private String logisticsProviderNameEndswith;
  /**
   * 物流商的名称 比较(isnull)
   */
  private Boolean logisticsProviderNameIsnull;
  /**
   * 物流商的名称 比较(isnotnull)
   */
  private Boolean logisticsProviderNameIsnotnull;

  /**
   * 物流商(范围搜索)
   */
  private List<Long> logisticsProviderInList;

  /**
   * 物流方式
   */
  private Long logisticsChannel;

  /**
   * 物流方式 比较(eq)
   */
  private Long logisticsChannelEq;
  /**
   * 物流方式 比较(neq)
   */
  private Long logisticsChannelNeq;
  /**
   * 物流方式 比较(gt)
   */
  private Long logisticsChannelGt;
  /**
   * 物流方式 比较(gte)
   */
  private Long logisticsChannelGte;
  /**
   * 物流方式 比较(lt)
   */
  private Long logisticsChannelLt;
  /**
   * 物流方式 比较(lte)
   */
  private Long logisticsChannelLte;
  /**
   * 物流方式 比较(contains)
   */
  private Long logisticsChannelContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private Long logisticsChannelNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private Long logisticsChannelStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private Long logisticsChannelEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean logisticsChannelIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean logisticsChannelIsnotnull;
  /**
   * 物流方式的名称 比较(eq)
   */
  private String logisticsChannelLabelEq;
  /**
   * 物流方式的名称 比较(neq)
   */
  private String logisticsChannelLabelNeq;
  /**
   * 物流方式的名称 比较(gt)
   */
  private String logisticsChannelLabelGt;
  /**
   * 物流方式的名称 比较(gte)
   */
  private String logisticsChannelLabelGte;
  /**
   * 物流方式的名称 比较(lt)
   */
  private String logisticsChannelLabelLt;
  /**
   * 物流方式的名称 比较(lte)
   */
  private String logisticsChannelLabelLte;
  /**
   * 物流方式的名称 比较(contains)
   */
  private String logisticsChannelLabelContains;
  /**
   * 物流方式的名称 比较(notcontains)
   */
  private String logisticsChannelLabelNotcontains;
  /**
   * 物流方式的名称 比较(startswith)
   */
  private String logisticsChannelLabelStartswith;
  /**
   * 物流方式的名称 比较(endswith)
   */
  private String logisticsChannelLabelEndswith;
  /**
   * 物流方式的名称 比较(isnull)
   */
  private Boolean logisticsChannelLabelIsnull;
  /**
   * 物流方式的名称 比较(isnotnull)
   */
  private Boolean logisticsChannelLabelIsnotnull;

  /**
   * 物流方式(范围搜索)
   */
  private List<Long> logisticsChannelInList;

  /**
   * 发货仓库
   */
  private Long warehouseActDeliveryWarehouse;

  /**
   * 发货仓库 比较(eq)
   */
  private Long warehouseActDeliveryWarehouseEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long warehouseActDeliveryWarehouseNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long warehouseActDeliveryWarehouseGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long warehouseActDeliveryWarehouseGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long warehouseActDeliveryWarehouseLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long warehouseActDeliveryWarehouseLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long warehouseActDeliveryWarehouseContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long warehouseActDeliveryWarehouseNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long warehouseActDeliveryWarehouseStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long warehouseActDeliveryWarehouseEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean warehouseActDeliveryWarehouseIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean warehouseActDeliveryWarehouseIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String warehouseActDeliveryWarehouseNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String warehouseActDeliveryWarehouseNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String warehouseActDeliveryWarehouseNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String warehouseActDeliveryWarehouseNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String warehouseActDeliveryWarehouseNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String warehouseActDeliveryWarehouseNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String warehouseActDeliveryWarehouseNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String warehouseActDeliveryWarehouseNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String warehouseActDeliveryWarehouseNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String warehouseActDeliveryWarehouseNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseActDeliveryWarehouseNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseActDeliveryWarehouseNameIsnotnull;

  /**
   * 发货仓库(范围搜索)
   */
  private List<Long> warehouseActDeliveryWarehouseInList;

  /**
   * 备选仓库
   */
  private Long warehouseActOptionWarehouse;

  /**
   * 备选仓库 比较(eq)
   */
  private Long warehouseActOptionWarehouseEq;
  /**
   * 备选仓库 比较(neq)
   */
  private Long warehouseActOptionWarehouseNeq;
  /**
   * 备选仓库 比较(gt)
   */
  private Long warehouseActOptionWarehouseGt;
  /**
   * 备选仓库 比较(gte)
   */
  private Long warehouseActOptionWarehouseGte;
  /**
   * 备选仓库 比较(lt)
   */
  private Long warehouseActOptionWarehouseLt;
  /**
   * 备选仓库 比较(lte)
   */
  private Long warehouseActOptionWarehouseLte;
  /**
   * 备选仓库 比较(contains)
   */
  private Long warehouseActOptionWarehouseContains;
  /**
   * 备选仓库 比较(notcontains)
   */
  private Long warehouseActOptionWarehouseNotcontains;
  /**
   * 备选仓库 比较(startswith)
   */
  private Long warehouseActOptionWarehouseStartswith;
  /**
   * 备选仓库 比较(endswith)
   */
  private Long warehouseActOptionWarehouseEndswith;
  /**
   * 备选仓库 比较(isnull)
   */
  private Boolean warehouseActOptionWarehouseIsnull;
  /**
   * 备选仓库 比较(isnotnull)
   */
  private Boolean warehouseActOptionWarehouseIsnotnull;
  /**
   * 备选仓库的仓库名称 比较(eq)
   */
  private String warehouseActOptionWarehouseNameEq;
  /**
   * 备选仓库的仓库名称 比较(neq)
   */
  private String warehouseActOptionWarehouseNameNeq;
  /**
   * 备选仓库的仓库名称 比较(gt)
   */
  private String warehouseActOptionWarehouseNameGt;
  /**
   * 备选仓库的仓库名称 比较(gte)
   */
  private String warehouseActOptionWarehouseNameGte;
  /**
   * 备选仓库的仓库名称 比较(lt)
   */
  private String warehouseActOptionWarehouseNameLt;
  /**
   * 备选仓库的仓库名称 比较(lte)
   */
  private String warehouseActOptionWarehouseNameLte;
  /**
   * 备选仓库的仓库名称 比较(contains)
   */
  private String warehouseActOptionWarehouseNameContains;
  /**
   * 备选仓库的仓库名称 比较(notcontains)
   */
  private String warehouseActOptionWarehouseNameNotcontains;
  /**
   * 备选仓库的仓库名称 比较(startswith)
   */
  private String warehouseActOptionWarehouseNameStartswith;
  /**
   * 备选仓库的仓库名称 比较(endswith)
   */
  private String warehouseActOptionWarehouseNameEndswith;
  /**
   * 备选仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseActOptionWarehouseNameIsnull;
  /**
   * 备选仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseActOptionWarehouseNameIsnotnull;

  /**
   * 备选仓库(范围搜索)
   */
  private List<Long> warehouseActOptionWarehouseInList;

  /**
   * 自动覆盖订单原有仓库
   */
  private String warehouseActAutoCoverOriginal;

  /**
   * 自动覆盖订单原有仓库 比较(eq)
   */
  private String warehouseActAutoCoverOriginalEq;
  /**
   * 自动覆盖订单原有仓库 比较(neq)
   */
  private String warehouseActAutoCoverOriginalNeq;
  /**
   * 自动覆盖订单原有仓库 比较(gt)
   */
  private String warehouseActAutoCoverOriginalGt;
  /**
   * 自动覆盖订单原有仓库 比较(gte)
   */
  private String warehouseActAutoCoverOriginalGte;
  /**
   * 自动覆盖订单原有仓库 比较(lt)
   */
  private String warehouseActAutoCoverOriginalLt;
  /**
   * 自动覆盖订单原有仓库 比较(lte)
   */
  private String warehouseActAutoCoverOriginalLte;
  /**
   * 自动覆盖订单原有仓库 比较(contains)
   */
  private String warehouseActAutoCoverOriginalContains;
  /**
   * 自动覆盖订单原有仓库 比较(notcontains)
   */
  private String warehouseActAutoCoverOriginalNotcontains;
  /**
   * 自动覆盖订单原有仓库 比较(startswith)
   */
  private String warehouseActAutoCoverOriginalStartswith;
  /**
   * 自动覆盖订单原有仓库 比较(endswith)
   */
  private String warehouseActAutoCoverOriginalEndswith;
  /**
   * 自动覆盖订单原有仓库 比较(isnull)
   */
  private Boolean warehouseActAutoCoverOriginalIsnull;
  /**
   * 自动覆盖订单原有仓库 比较(isnotnull)
   */
  private Boolean warehouseActAutoCoverOriginalIsnotnull;

  /**
   * 自动覆盖订单原有仓库(精确搜索)
   */
  private List<String> warehouseActAutoCoverOriginalInList;

  /**
   * 库存扣减类型
   */
  private String warehouseActInventoryDeductionType;

  /**
   * 库存扣减类型 比较(eq)
   */
  private String warehouseActInventoryDeductionTypeEq;
  /**
   * 库存扣减类型 比较(neq)
   */
  private String warehouseActInventoryDeductionTypeNeq;
  /**
   * 库存扣减类型 比较(gt)
   */
  private String warehouseActInventoryDeductionTypeGt;
  /**
   * 库存扣减类型 比较(gte)
   */
  private String warehouseActInventoryDeductionTypeGte;
  /**
   * 库存扣减类型 比较(lt)
   */
  private String warehouseActInventoryDeductionTypeLt;
  /**
   * 库存扣减类型 比较(lte)
   */
  private String warehouseActInventoryDeductionTypeLte;
  /**
   * 库存扣减类型 比较(contains)
   */
  private String warehouseActInventoryDeductionTypeContains;
  /**
   * 库存扣减类型 比较(notcontains)
   */
  private String warehouseActInventoryDeductionTypeNotcontains;
  /**
   * 库存扣减类型 比较(startswith)
   */
  private String warehouseActInventoryDeductionTypeStartswith;
  /**
   * 库存扣减类型 比较(endswith)
   */
  private String warehouseActInventoryDeductionTypeEndswith;
  /**
   * 库存扣减类型 比较(isnull)
   */
  private Boolean warehouseActInventoryDeductionTypeIsnull;
  /**
   * 库存扣减类型 比较(isnotnull)
   */
  private Boolean warehouseActInventoryDeductionTypeIsnotnull;

  /**
   * 库存扣减类型(精确搜索)
   */
  private List<String> warehouseActInventoryDeductionTypeInList;

  /**
   * 海外仓物流自动设定对应海外仓
   */
  private String logisticsActOverseasWarehouseAutoMapping;

  /**
   * 海外仓物流自动设定对应海外仓 比较(eq)
   */
  private String logisticsActOverseasWarehouseAutoMappingEq;
  /**
   * 海外仓物流自动设定对应海外仓 比较(neq)
   */
  private String logisticsActOverseasWarehouseAutoMappingNeq;
  /**
   * 海外仓物流自动设定对应海外仓 比较(gt)
   */
  private String logisticsActOverseasWarehouseAutoMappingGt;
  /**
   * 海外仓物流自动设定对应海外仓 比较(gte)
   */
  private String logisticsActOverseasWarehouseAutoMappingGte;
  /**
   * 海外仓物流自动设定对应海外仓 比较(lt)
   */
  private String logisticsActOverseasWarehouseAutoMappingLt;
  /**
   * 海外仓物流自动设定对应海外仓 比较(lte)
   */
  private String logisticsActOverseasWarehouseAutoMappingLte;
  /**
   * 海外仓物流自动设定对应海外仓 比较(contains)
   */
  private String logisticsActOverseasWarehouseAutoMappingContains;
  /**
   * 海外仓物流自动设定对应海外仓 比较(notcontains)
   */
  private String logisticsActOverseasWarehouseAutoMappingNotcontains;
  /**
   * 海外仓物流自动设定对应海外仓 比较(startswith)
   */
  private String logisticsActOverseasWarehouseAutoMappingStartswith;
  /**
   * 海外仓物流自动设定对应海外仓 比较(endswith)
   */
  private String logisticsActOverseasWarehouseAutoMappingEndswith;
  /**
   * 海外仓物流自动设定对应海外仓 比较(isnull)
   */
  private Boolean logisticsActOverseasWarehouseAutoMappingIsnull;
  /**
   * 海外仓物流自动设定对应海外仓 比较(isnotnull)
   */
  private Boolean logisticsActOverseasWarehouseAutoMappingIsnotnull;

  /**
   * 海外仓物流自动设定对应海外仓(精确搜索)
   */
  private List<String> logisticsActOverseasWarehouseAutoMappingInList;

  /**
   * 设定方式
   */
  private String logisticsActSettingMethod;

  /**
   * 设定方式 比较(eq)
   */
  private String logisticsActSettingMethodEq;
  /**
   * 设定方式 比较(neq)
   */
  private String logisticsActSettingMethodNeq;
  /**
   * 设定方式 比较(gt)
   */
  private String logisticsActSettingMethodGt;
  /**
   * 设定方式 比较(gte)
   */
  private String logisticsActSettingMethodGte;
  /**
   * 设定方式 比较(lt)
   */
  private String logisticsActSettingMethodLt;
  /**
   * 设定方式 比较(lte)
   */
  private String logisticsActSettingMethodLte;
  /**
   * 设定方式 比较(contains)
   */
  private String logisticsActSettingMethodContains;
  /**
   * 设定方式 比较(notcontains)
   */
  private String logisticsActSettingMethodNotcontains;
  /**
   * 设定方式 比较(startswith)
   */
  private String logisticsActSettingMethodStartswith;
  /**
   * 设定方式 比较(endswith)
   */
  private String logisticsActSettingMethodEndswith;
  /**
   * 设定方式 比较(isnull)
   */
  private Boolean logisticsActSettingMethodIsnull;
  /**
   * 设定方式 比较(isnotnull)
   */
  private Boolean logisticsActSettingMethodIsnotnull;

  /**
   * 设定方式(精确搜索)
   */
  private List<String> logisticsActSettingMethodInList;

  /**
   * 物流方式
   */
  private Long logisticsActChannel;

  /**
   * 物流方式 比较(eq)
   */
  private Long logisticsActChannelEq;
  /**
   * 物流方式 比较(neq)
   */
  private Long logisticsActChannelNeq;
  /**
   * 物流方式 比较(gt)
   */
  private Long logisticsActChannelGt;
  /**
   * 物流方式 比较(gte)
   */
  private Long logisticsActChannelGte;
  /**
   * 物流方式 比较(lt)
   */
  private Long logisticsActChannelLt;
  /**
   * 物流方式 比较(lte)
   */
  private Long logisticsActChannelLte;
  /**
   * 物流方式 比较(contains)
   */
  private Long logisticsActChannelContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private Long logisticsActChannelNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private Long logisticsActChannelStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private Long logisticsActChannelEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean logisticsActChannelIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean logisticsActChannelIsnotnull;
  /**
   * 物流方式的名称 比较(eq)
   */
  private String logisticsActChannelLabelEq;
  /**
   * 物流方式的名称 比较(neq)
   */
  private String logisticsActChannelLabelNeq;
  /**
   * 物流方式的名称 比较(gt)
   */
  private String logisticsActChannelLabelGt;
  /**
   * 物流方式的名称 比较(gte)
   */
  private String logisticsActChannelLabelGte;
  /**
   * 物流方式的名称 比较(lt)
   */
  private String logisticsActChannelLabelLt;
  /**
   * 物流方式的名称 比较(lte)
   */
  private String logisticsActChannelLabelLte;
  /**
   * 物流方式的名称 比较(contains)
   */
  private String logisticsActChannelLabelContains;
  /**
   * 物流方式的名称 比较(notcontains)
   */
  private String logisticsActChannelLabelNotcontains;
  /**
   * 物流方式的名称 比较(startswith)
   */
  private String logisticsActChannelLabelStartswith;
  /**
   * 物流方式的名称 比较(endswith)
   */
  private String logisticsActChannelLabelEndswith;
  /**
   * 物流方式的名称 比较(isnull)
   */
  private Boolean logisticsActChannelLabelIsnull;
  /**
   * 物流方式的名称 比较(isnotnull)
   */
  private Boolean logisticsActChannelLabelIsnotnull;

  /**
   * 物流方式(范围搜索)
   */
  private List<Long> logisticsActChannelInList;

  /**
   * 自动覆盖订单原有物流
   */
  private String logisticsActAutoCoverOriginal;

  /**
   * 自动覆盖订单原有物流 比较(eq)
   */
  private String logisticsActAutoCoverOriginalEq;
  /**
   * 自动覆盖订单原有物流 比较(neq)
   */
  private String logisticsActAutoCoverOriginalNeq;
  /**
   * 自动覆盖订单原有物流 比较(gt)
   */
  private String logisticsActAutoCoverOriginalGt;
  /**
   * 自动覆盖订单原有物流 比较(gte)
   */
  private String logisticsActAutoCoverOriginalGte;
  /**
   * 自动覆盖订单原有物流 比较(lt)
   */
  private String logisticsActAutoCoverOriginalLt;
  /**
   * 自动覆盖订单原有物流 比较(lte)
   */
  private String logisticsActAutoCoverOriginalLte;
  /**
   * 自动覆盖订单原有物流 比较(contains)
   */
  private String logisticsActAutoCoverOriginalContains;
  /**
   * 自动覆盖订单原有物流 比较(notcontains)
   */
  private String logisticsActAutoCoverOriginalNotcontains;
  /**
   * 自动覆盖订单原有物流 比较(startswith)
   */
  private String logisticsActAutoCoverOriginalStartswith;
  /**
   * 自动覆盖订单原有物流 比较(endswith)
   */
  private String logisticsActAutoCoverOriginalEndswith;
  /**
   * 自动覆盖订单原有物流 比较(isnull)
   */
  private Boolean logisticsActAutoCoverOriginalIsnull;
  /**
   * 自动覆盖订单原有物流 比较(isnotnull)
   */
  private Boolean logisticsActAutoCoverOriginalIsnotnull;

  /**
   * 自动覆盖订单原有物流(精确搜索)
   */
  private List<String> logisticsActAutoCoverOriginalInList;

  /**
   * 比价方式
   */
  private String logisticsActPriceParity;

  /**
   * 比价方式 比较(eq)
   */
  private String logisticsActPriceParityEq;
  /**
   * 比价方式 比较(neq)
   */
  private String logisticsActPriceParityNeq;
  /**
   * 比价方式 比较(gt)
   */
  private String logisticsActPriceParityGt;
  /**
   * 比价方式 比较(gte)
   */
  private String logisticsActPriceParityGte;
  /**
   * 比价方式 比较(lt)
   */
  private String logisticsActPriceParityLt;
  /**
   * 比价方式 比较(lte)
   */
  private String logisticsActPriceParityLte;
  /**
   * 比价方式 比较(contains)
   */
  private String logisticsActPriceParityContains;
  /**
   * 比价方式 比较(notcontains)
   */
  private String logisticsActPriceParityNotcontains;
  /**
   * 比价方式 比较(startswith)
   */
  private String logisticsActPriceParityStartswith;
  /**
   * 比价方式 比较(endswith)
   */
  private String logisticsActPriceParityEndswith;
  /**
   * 比价方式 比较(isnull)
   */
  private Boolean logisticsActPriceParityIsnull;
  /**
   * 比价方式 比较(isnotnull)
   */
  private Boolean logisticsActPriceParityIsnotnull;

  /**
   * 比价方式(精确搜索)
   */
  private List<String> logisticsActPriceParityInList;

  /**
   * 省州、城市为空填充
   */
  private String logisticsAddressActFill;

  /**
   * 省州、城市为空填充 比较(eq)
   */
  private String logisticsAddressActFillEq;
  /**
   * 省州、城市为空填充 比较(neq)
   */
  private String logisticsAddressActFillNeq;
  /**
   * 省州、城市为空填充 比较(gt)
   */
  private String logisticsAddressActFillGt;
  /**
   * 省州、城市为空填充 比较(gte)
   */
  private String logisticsAddressActFillGte;
  /**
   * 省州、城市为空填充 比较(lt)
   */
  private String logisticsAddressActFillLt;
  /**
   * 省州、城市为空填充 比较(lte)
   */
  private String logisticsAddressActFillLte;
  /**
   * 省州、城市为空填充 比较(contains)
   */
  private String logisticsAddressActFillContains;
  /**
   * 省州、城市为空填充 比较(notcontains)
   */
  private String logisticsAddressActFillNotcontains;
  /**
   * 省州、城市为空填充 比较(startswith)
   */
  private String logisticsAddressActFillStartswith;
  /**
   * 省州、城市为空填充 比较(endswith)
   */
  private String logisticsAddressActFillEndswith;
  /**
   * 省州、城市为空填充 比较(isnull)
   */
  private Boolean logisticsAddressActFillIsnull;
  /**
   * 省州、城市为空填充 比较(isnotnull)
   */
  private Boolean logisticsAddressActFillIsnotnull;

  /**
   * 省州、城市为空填充(精确搜索)
   */
  private List<String> logisticsAddressActFillInList;

  /**
   * 省州全称/简称替换
   */
  private String logisticsAddressActSelectQJ;

  /**
   * 省州全称/简称替换 比较(eq)
   */
  private String logisticsAddressActSelectQJEq;
  /**
   * 省州全称/简称替换 比较(neq)
   */
  private String logisticsAddressActSelectQJNeq;
  /**
   * 省州全称/简称替换 比较(gt)
   */
  private String logisticsAddressActSelectQJGt;
  /**
   * 省州全称/简称替换 比较(gte)
   */
  private String logisticsAddressActSelectQJGte;
  /**
   * 省州全称/简称替换 比较(lt)
   */
  private String logisticsAddressActSelectQJLt;
  /**
   * 省州全称/简称替换 比较(lte)
   */
  private String logisticsAddressActSelectQJLte;
  /**
   * 省州全称/简称替换 比较(contains)
   */
  private String logisticsAddressActSelectQJContains;
  /**
   * 省州全称/简称替换 比较(notcontains)
   */
  private String logisticsAddressActSelectQJNotcontains;
  /**
   * 省州全称/简称替换 比较(startswith)
   */
  private String logisticsAddressActSelectQJStartswith;
  /**
   * 省州全称/简称替换 比较(endswith)
   */
  private String logisticsAddressActSelectQJEndswith;
  /**
   * 省州全称/简称替换 比较(isnull)
   */
  private Boolean logisticsAddressActSelectQJIsnull;
  /**
   * 省州全称/简称替换 比较(isnotnull)
   */
  private Boolean logisticsAddressActSelectQJIsnotnull;

  /**
   * 省州全称/简称替换(精确搜索)
   */
  private List<String> logisticsAddressActSelectQJInList;

  /**
   * 门牌号解析1(模糊搜索)
   */
  private String logisticsAddressActHouseNoAnalysis1;

  /**
   * 门牌号解析1 比较(eq)
   */
  private String logisticsAddressActHouseNoAnalysis1Eq;
  /**
   * 门牌号解析1 比较(neq)
   */
  private String logisticsAddressActHouseNoAnalysis1Neq;
  /**
   * 门牌号解析1 比较(gt)
   */
  private String logisticsAddressActHouseNoAnalysis1Gt;
  /**
   * 门牌号解析1 比较(gte)
   */
  private String logisticsAddressActHouseNoAnalysis1Gte;
  /**
   * 门牌号解析1 比较(lt)
   */
  private String logisticsAddressActHouseNoAnalysis1Lt;
  /**
   * 门牌号解析1 比较(lte)
   */
  private String logisticsAddressActHouseNoAnalysis1Lte;
  /**
   * 门牌号解析1 比较(contains)
   */
  private String logisticsAddressActHouseNoAnalysis1Contains;
  /**
   * 门牌号解析1 比较(notcontains)
   */
  private String logisticsAddressActHouseNoAnalysis1Notcontains;
  /**
   * 门牌号解析1 比较(startswith)
   */
  private String logisticsAddressActHouseNoAnalysis1Startswith;
  /**
   * 门牌号解析1 比较(endswith)
   */
  private String logisticsAddressActHouseNoAnalysis1Endswith;
  /**
   * 门牌号解析1 比较(isnull)
   */
  private Boolean logisticsAddressActHouseNoAnalysis1Isnull;
  /**
   * 门牌号解析1 比较(isnotnull)
   */
  private Boolean logisticsAddressActHouseNoAnalysis1Isnotnull;

  /**
   * 门牌号解析1(精确搜索)
   */
  private List<String> logisticsAddressActHouseNoAnalysis1InList;

  /**
   * 门牌号解析2(模糊搜索)
   */
  private String logisticsAddressActHouseNoAnalysis2;

  /**
   * 门牌号解析2 比较(eq)
   */
  private String logisticsAddressActHouseNoAnalysis2Eq;
  /**
   * 门牌号解析2 比较(neq)
   */
  private String logisticsAddressActHouseNoAnalysis2Neq;
  /**
   * 门牌号解析2 比较(gt)
   */
  private String logisticsAddressActHouseNoAnalysis2Gt;
  /**
   * 门牌号解析2 比较(gte)
   */
  private String logisticsAddressActHouseNoAnalysis2Gte;
  /**
   * 门牌号解析2 比较(lt)
   */
  private String logisticsAddressActHouseNoAnalysis2Lt;
  /**
   * 门牌号解析2 比较(lte)
   */
  private String logisticsAddressActHouseNoAnalysis2Lte;
  /**
   * 门牌号解析2 比较(contains)
   */
  private String logisticsAddressActHouseNoAnalysis2Contains;
  /**
   * 门牌号解析2 比较(notcontains)
   */
  private String logisticsAddressActHouseNoAnalysis2Notcontains;
  /**
   * 门牌号解析2 比较(startswith)
   */
  private String logisticsAddressActHouseNoAnalysis2Startswith;
  /**
   * 门牌号解析2 比较(endswith)
   */
  private String logisticsAddressActHouseNoAnalysis2Endswith;
  /**
   * 门牌号解析2 比较(isnull)
   */
  private Boolean logisticsAddressActHouseNoAnalysis2Isnull;
  /**
   * 门牌号解析2 比较(isnotnull)
   */
  private Boolean logisticsAddressActHouseNoAnalysis2Isnotnull;

  /**
   * 门牌号解析2(精确搜索)
   */
  private List<String> logisticsAddressActHouseNoAnalysis2InList;

  /**
   * 门牌号解析3(模糊搜索)
   */
  private String logisticsAddressActHouseNoAnalysis3;

  /**
   * 门牌号解析3 比较(eq)
   */
  private String logisticsAddressActHouseNoAnalysis3Eq;
  /**
   * 门牌号解析3 比较(neq)
   */
  private String logisticsAddressActHouseNoAnalysis3Neq;
  /**
   * 门牌号解析3 比较(gt)
   */
  private String logisticsAddressActHouseNoAnalysis3Gt;
  /**
   * 门牌号解析3 比较(gte)
   */
  private String logisticsAddressActHouseNoAnalysis3Gte;
  /**
   * 门牌号解析3 比较(lt)
   */
  private String logisticsAddressActHouseNoAnalysis3Lt;
  /**
   * 门牌号解析3 比较(lte)
   */
  private String logisticsAddressActHouseNoAnalysis3Lte;
  /**
   * 门牌号解析3 比较(contains)
   */
  private String logisticsAddressActHouseNoAnalysis3Contains;
  /**
   * 门牌号解析3 比较(notcontains)
   */
  private String logisticsAddressActHouseNoAnalysis3Notcontains;
  /**
   * 门牌号解析3 比较(startswith)
   */
  private String logisticsAddressActHouseNoAnalysis3Startswith;
  /**
   * 门牌号解析3 比较(endswith)
   */
  private String logisticsAddressActHouseNoAnalysis3Endswith;
  /**
   * 门牌号解析3 比较(isnull)
   */
  private Boolean logisticsAddressActHouseNoAnalysis3Isnull;
  /**
   * 门牌号解析3 比较(isnotnull)
   */
  private Boolean logisticsAddressActHouseNoAnalysis3Isnotnull;

  /**
   * 门牌号解析3(精确搜索)
   */
  private List<String> logisticsAddressActHouseNoAnalysis3InList;

  /**
   * 电话号码简化1(模糊搜索)
   */
  private String addressActPhoneSimplify1;

  /**
   * 电话号码简化1 比较(eq)
   */
  private String addressActPhoneSimplify1Eq;
  /**
   * 电话号码简化1 比较(neq)
   */
  private String addressActPhoneSimplify1Neq;
  /**
   * 电话号码简化1 比较(gt)
   */
  private String addressActPhoneSimplify1Gt;
  /**
   * 电话号码简化1 比较(gte)
   */
  private String addressActPhoneSimplify1Gte;
  /**
   * 电话号码简化1 比较(lt)
   */
  private String addressActPhoneSimplify1Lt;
  /**
   * 电话号码简化1 比较(lte)
   */
  private String addressActPhoneSimplify1Lte;
  /**
   * 电话号码简化1 比较(contains)
   */
  private String addressActPhoneSimplify1Contains;
  /**
   * 电话号码简化1 比较(notcontains)
   */
  private String addressActPhoneSimplify1Notcontains;
  /**
   * 电话号码简化1 比较(startswith)
   */
  private String addressActPhoneSimplify1Startswith;
  /**
   * 电话号码简化1 比较(endswith)
   */
  private String addressActPhoneSimplify1Endswith;
  /**
   * 电话号码简化1 比较(isnull)
   */
  private Boolean addressActPhoneSimplify1Isnull;
  /**
   * 电话号码简化1 比较(isnotnull)
   */
  private Boolean addressActPhoneSimplify1Isnotnull;

  /**
   * 电话号码简化1(精确搜索)
   */
  private List<String> addressActPhoneSimplify1InList;

  /**
   * 电话号码简化2(模糊搜索)
   */
  private String addressActPhoneSimplify2;

  /**
   * 电话号码简化2 比较(eq)
   */
  private String addressActPhoneSimplify2Eq;
  /**
   * 电话号码简化2 比较(neq)
   */
  private String addressActPhoneSimplify2Neq;
  /**
   * 电话号码简化2 比较(gt)
   */
  private String addressActPhoneSimplify2Gt;
  /**
   * 电话号码简化2 比较(gte)
   */
  private String addressActPhoneSimplify2Gte;
  /**
   * 电话号码简化2 比较(lt)
   */
  private String addressActPhoneSimplify2Lt;
  /**
   * 电话号码简化2 比较(lte)
   */
  private String addressActPhoneSimplify2Lte;
  /**
   * 电话号码简化2 比较(contains)
   */
  private String addressActPhoneSimplify2Contains;
  /**
   * 电话号码简化2 比较(notcontains)
   */
  private String addressActPhoneSimplify2Notcontains;
  /**
   * 电话号码简化2 比较(startswith)
   */
  private String addressActPhoneSimplify2Startswith;
  /**
   * 电话号码简化2 比较(endswith)
   */
  private String addressActPhoneSimplify2Endswith;
  /**
   * 电话号码简化2 比较(isnull)
   */
  private Boolean addressActPhoneSimplify2Isnull;
  /**
   * 电话号码简化2 比较(isnotnull)
   */
  private Boolean addressActPhoneSimplify2Isnotnull;

  /**
   * 电话号码简化2(精确搜索)
   */
  private List<String> addressActPhoneSimplify2InList;

  /**
   * 电话号码简化3(模糊搜索)
   */
  private String addressActPhoneSimplify3;

  /**
   * 电话号码简化3 比较(eq)
   */
  private String addressActPhoneSimplify3Eq;
  /**
   * 电话号码简化3 比较(neq)
   */
  private String addressActPhoneSimplify3Neq;
  /**
   * 电话号码简化3 比较(gt)
   */
  private String addressActPhoneSimplify3Gt;
  /**
   * 电话号码简化3 比较(gte)
   */
  private String addressActPhoneSimplify3Gte;
  /**
   * 电话号码简化3 比较(lt)
   */
  private String addressActPhoneSimplify3Lt;
  /**
   * 电话号码简化3 比较(lte)
   */
  private String addressActPhoneSimplify3Lte;
  /**
   * 电话号码简化3 比较(contains)
   */
  private String addressActPhoneSimplify3Contains;
  /**
   * 电话号码简化3 比较(notcontains)
   */
  private String addressActPhoneSimplify3Notcontains;
  /**
   * 电话号码简化3 比较(startswith)
   */
  private String addressActPhoneSimplify3Startswith;
  /**
   * 电话号码简化3 比较(endswith)
   */
  private String addressActPhoneSimplify3Endswith;
  /**
   * 电话号码简化3 比较(isnull)
   */
  private Boolean addressActPhoneSimplify3Isnull;
  /**
   * 电话号码简化3 比较(isnotnull)
   */
  private Boolean addressActPhoneSimplify3Isnotnull;

  /**
   * 电话号码简化3(精确搜索)
   */
  private List<String> addressActPhoneSimplify3InList;

  /**
   * 电话号码简化4(模糊搜索)
   */
  private String addressActPhoneSimplify4;

  /**
   * 电话号码简化4 比较(eq)
   */
  private String addressActPhoneSimplify4Eq;
  /**
   * 电话号码简化4 比较(neq)
   */
  private String addressActPhoneSimplify4Neq;
  /**
   * 电话号码简化4 比较(gt)
   */
  private String addressActPhoneSimplify4Gt;
  /**
   * 电话号码简化4 比较(gte)
   */
  private String addressActPhoneSimplify4Gte;
  /**
   * 电话号码简化4 比较(lt)
   */
  private String addressActPhoneSimplify4Lt;
  /**
   * 电话号码简化4 比较(lte)
   */
  private String addressActPhoneSimplify4Lte;
  /**
   * 电话号码简化4 比较(contains)
   */
  private String addressActPhoneSimplify4Contains;
  /**
   * 电话号码简化4 比较(notcontains)
   */
  private String addressActPhoneSimplify4Notcontains;
  /**
   * 电话号码简化4 比较(startswith)
   */
  private String addressActPhoneSimplify4Startswith;
  /**
   * 电话号码简化4 比较(endswith)
   */
  private String addressActPhoneSimplify4Endswith;
  /**
   * 电话号码简化4 比较(isnull)
   */
  private Boolean addressActPhoneSimplify4Isnull;
  /**
   * 电话号码简化4 比较(isnotnull)
   */
  private Boolean addressActPhoneSimplify4Isnotnull;

  /**
   * 电话号码简化4(精确搜索)
   */
  private List<String> addressActPhoneSimplify4InList;

  /**
   * 邮编处理1(模糊搜索)
   */
  private String addressActPostHandle1;

  /**
   * 邮编处理1 比较(eq)
   */
  private String addressActPostHandle1Eq;
  /**
   * 邮编处理1 比较(neq)
   */
  private String addressActPostHandle1Neq;
  /**
   * 邮编处理1 比较(gt)
   */
  private String addressActPostHandle1Gt;
  /**
   * 邮编处理1 比较(gte)
   */
  private String addressActPostHandle1Gte;
  /**
   * 邮编处理1 比较(lt)
   */
  private String addressActPostHandle1Lt;
  /**
   * 邮编处理1 比较(lte)
   */
  private String addressActPostHandle1Lte;
  /**
   * 邮编处理1 比较(contains)
   */
  private String addressActPostHandle1Contains;
  /**
   * 邮编处理1 比较(notcontains)
   */
  private String addressActPostHandle1Notcontains;
  /**
   * 邮编处理1 比较(startswith)
   */
  private String addressActPostHandle1Startswith;
  /**
   * 邮编处理1 比较(endswith)
   */
  private String addressActPostHandle1Endswith;
  /**
   * 邮编处理1 比较(isnull)
   */
  private Boolean addressActPostHandle1Isnull;
  /**
   * 邮编处理1 比较(isnotnull)
   */
  private Boolean addressActPostHandle1Isnotnull;

  /**
   * 邮编处理1(精确搜索)
   */
  private List<String> addressActPostHandle1InList;

  /**
   * 邮编处理2(模糊搜索)
   */
  private String addressActPostHandle2;

  /**
   * 邮编处理2 比较(eq)
   */
  private String addressActPostHandle2Eq;
  /**
   * 邮编处理2 比较(neq)
   */
  private String addressActPostHandle2Neq;
  /**
   * 邮编处理2 比较(gt)
   */
  private String addressActPostHandle2Gt;
  /**
   * 邮编处理2 比较(gte)
   */
  private String addressActPostHandle2Gte;
  /**
   * 邮编处理2 比较(lt)
   */
  private String addressActPostHandle2Lt;
  /**
   * 邮编处理2 比较(lte)
   */
  private String addressActPostHandle2Lte;
  /**
   * 邮编处理2 比较(contains)
   */
  private String addressActPostHandle2Contains;
  /**
   * 邮编处理2 比较(notcontains)
   */
  private String addressActPostHandle2Notcontains;
  /**
   * 邮编处理2 比较(startswith)
   */
  private String addressActPostHandle2Startswith;
  /**
   * 邮编处理2 比较(endswith)
   */
  private String addressActPostHandle2Endswith;
  /**
   * 邮编处理2 比较(isnull)
   */
  private Boolean addressActPostHandle2Isnull;
  /**
   * 邮编处理2 比较(isnotnull)
   */
  private Boolean addressActPostHandle2Isnotnull;

  /**
   * 邮编处理2(精确搜索)
   */
  private List<String> addressActPostHandle2InList;

  /**
   * 标发规则
   */
  private String issuActRules;

  /**
   * 标发规则 比较(eq)
   */
  private String issuActRulesEq;
  /**
   * 标发规则 比较(neq)
   */
  private String issuActRulesNeq;
  /**
   * 标发规则 比较(gt)
   */
  private String issuActRulesGt;
  /**
   * 标发规则 比较(gte)
   */
  private String issuActRulesGte;
  /**
   * 标发规则 比较(lt)
   */
  private String issuActRulesLt;
  /**
   * 标发规则 比较(lte)
   */
  private String issuActRulesLte;
  /**
   * 标发规则 比较(contains)
   */
  private String issuActRulesContains;
  /**
   * 标发规则 比较(notcontains)
   */
  private String issuActRulesNotcontains;
  /**
   * 标发规则 比较(startswith)
   */
  private String issuActRulesStartswith;
  /**
   * 标发规则 比较(endswith)
   */
  private String issuActRulesEndswith;
  /**
   * 标发规则 比较(isnull)
   */
  private Boolean issuActRulesIsnull;
  /**
   * 标发规则 比较(isnotnull)
   */
  private Boolean issuActRulesIsnotnull;

  /**
   * 标发规则(精确搜索)
   */
  private List<String> issuActRulesInList;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;
  /**
   * 创建人的显示用户名 比较(eq)
   */
  private String createUserNameEq;
  /**
   * 创建人的显示用户名 比较(neq)
   */
  private String createUserNameNeq;
  /**
   * 创建人的显示用户名 比较(gt)
   */
  private String createUserNameGt;
  /**
   * 创建人的显示用户名 比较(gte)
   */
  private String createUserNameGte;
  /**
   * 创建人的显示用户名 比较(lt)
   */
  private String createUserNameLt;
  /**
   * 创建人的显示用户名 比较(lte)
   */
  private String createUserNameLte;
  /**
   * 创建人的显示用户名 比较(contains)
   */
  private String createUserNameContains;
  /**
   * 创建人的显示用户名 比较(notcontains)
   */
  private String createUserNameNotcontains;
  /**
   * 创建人的显示用户名 比较(startswith)
   */
  private String createUserNameStartswith;
  /**
   * 创建人的显示用户名 比较(endswith)
   */
  private String createUserNameEndswith;
  /**
   * 创建人的显示用户名 比较(isnull)
   */
  private Boolean createUserNameIsnull;
  /**
   * 创建人的显示用户名 比较(isnotnull)
   */
  private Boolean createUserNameIsnotnull;

  /**
   * 创建人(范围搜索)
   */
  private List<Long> createUserInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
